home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 011-020 / amok13 / rows / rows.dok < prev    next >
Text File  |  1993-11-04  |  7KB  |  173 lines
  1. ======================================================================
  2. Dokumentation zu "" Version 1.0
  3. Autor: Nicolas Benezan, Postwiesenstr. 2, D7000 Stuttgart 60
  4. ======================================================================
  5.  
  6. Kopierrecht
  7. ­­­­­­­­­­­
  8. Das komplette Packet (Quelltext, Dokumentation und Objectcode) ist
  9. Public-Domain-Software. Es darf beliebig kopiert und verbreitet werden
  10. solange...
  11.  
  12. * mein Name und dieser Kopierrechtshinweis erhalten bleiben,
  13. * die Vollständigkeit des ganzen Packets gewährleistet ist, und
  14. * mit dem Vertrieb dieser Software kein Gewinn erwirtschaftet wird.
  15.  
  16. Die Kommerzielle Nutzung ohne meine ausdrückliche schriftliche
  17. Genehmigung ist untersagt. Falls Sie dies beabsichtigen, nehmen Sie
  18. bitte unter oben genannter Adresse Kontakt mit mir auf.
  19.  
  20. Verbesserungsvorschläge sind stets willkommen. Falls Sie Veränderungen
  21. am Programm vornehmen, dokumentieren Sie diese bitte gut verständlich.
  22. Es würde mich freuen, wenn Sie mich über größere Veränderungen in
  23. Kenntnis setzen würden.
  24.  
  25. (c) 1988 by Nicolas Benezan. Alle Rechte vorbehalten.
  26.  
  27.  
  28. Übersicht
  29. ­­­­­­­­­
  30. * Umfang des Packets
  31. * Einleitung
  32. * Generische Datentypen
  33. * Der neue Datentyp "Row"
  34. * Beschreibung der Prozeduren
  35. * Testmodul
  36.  
  37.  
  38. Umfang des Packet
  39. ­­­­­­­­­­­­­­­­­
  40. Das komplette Packet "Rows" beinhaltet folgendes:
  41.  
  42. * Rows.dok          Diese Dokumentation
  43. * Rows.doc          Englische Dokumentation
  44. * Rows.def          Definitionsmodul
  45. * Rows.mod          Implementationsmodul
  46. * Rows.sym          Symboldatei (compiliertes Definitionsodul)
  47. * Rows.obj          Objektcode (compiliertes Implementationsmodul)
  48. * RowDemo.mod       Testmodul
  49. * RowDemo.obj       Compiliertes Testmodul
  50. * RowDemo           Ausführbares Testmodul
  51.  
  52.  
  53. Einleitung
  54. ­­­­­­­­­­
  55. Modula-II bietet einige wenige grundlegende Datenstrukturen und die
  56. Möglichkeit umfangreichere Strukturen zu konstruieren. Es unterstützt
  57. auch die Entwicklung generischer Datentypen. Das beste Beispiel hierfür
  58. ist der Typ "File", der nicht wie in Pascal zum Sprachumfang gehört,
  59. sondern aus dem Modul "FileSystem" importiert wird. Die auf diesen Typ
  60. ausführbaren Operationen werden in dem gleichen Modul angeboten.
  61. Das einzige, was der Kunde dieses Moduls wissen braucht, ist das
  62. abstrakte Konzept von Files.
  63. Dieses Modul stellt den generischen Datentyp "Row" zur Verfügung.
  64.  
  65.  
  66. Generischie Datentypen
  67. ­­­­­­­­­­­­­­­­­­­­­­
  68. In Modula-II (wie auch in den meisten anderen sog. Hochsprachen)
  69. kann man neue Typen durch Deklaration erstellen. Ein neuer Typ
  70. besteht aus einer Zusammensetzung von Komponenttypen. Der
  71. Nachteil der Typendeklaration ist, daß die Komponenttypen bei der
  72. Compilation schon eindeutig definiert sein müssen (entweder handelt
  73. es sich um einen fundamentalen Type (z.B. BOOLEAN) oder einen
  74. durch Deklaration bekannten Typ).
  75. Modula-II bietet vier Strukturierungsarten zum Erstellen neuer
  76. Typen: ARRAY, SET, RECORD und POINTER.
  77. Der letztere bietet die Vorteile der dynamischen Speicherverwaltung.
  78. Mit ihm kann man die unterschiedlichsten Typen definierten.
  79. Zum Beispiel eine Liste:
  80.   TYPE  listptr = POINTER TO list;
  81.         list    = RECORD
  82.                    item : T0;
  83.                    next : listptr
  84.                   END;
  85.  
  86. Um diese Liste sinnvoll zu benützen, entwickelt man entsprechende
  87. Prozeduren: Einfügen eines Elementes, Lesen eines Elementes usw.
  88. Die Prozeduren sind im eigentlichen Sinne unabhängig vom
  89. Komponententyp T0, aber der definierte Typ "list" hängt durch die
  90. Deklaration vom Typ T0 ab.
  91.  
  92. Ein generischer Datentyp kann mit beliebigen Komponententypen
  93. arbeiten!
  94. Modula-II unterstützt die Entwicklung von Modulen (sog.
  95. Datenkapseln), die einen generischen datentyp und die auf ihn
  96. ausführbaren Operationen exportiert.
  97. Die Unterstützung ist jedoch nicht vollkommen. Die Typenprüfung
  98. von Modula-2 muß umgangen werden. Es kann lediglich die Länge
  99. der Parameter geprüft werden. Ein Parameter darf gleichlang
  100. oder kürzer (Stringkonstanten) als bei Dim() deklariert sein.
  101.  
  102.  
  103. Der neue Datentyp "Row"
  104. ­­­­­­­­­­­­­­­­­­­­­­­
  105. "Rows" (deutsch: Reihen/Folgen) sind eine Art ARRAYs, jedoch mit
  106. dem Unterschied, daß die Elementanzahl nicht vor dem Compilieren
  107. sondern erst zur Laufzeit bekannt sein muß. Man kann also im laufenden
  108. Programm (wie in Basic, übrigens) die Länge einer Row mit Dim()
  109. festlegen. Rows sind jedoch nicht dynamisch, wie etwa dynamische
  110. Listen. Einmal dimensioniert, darf die Länge nicht mehr verändert
  111. werden, man kann also nich wie bei Listen Elemente einfügen oder
  112. entfernen. Man hat jedoch über einen Index (wie bei ARRAYs) direkten
  113. Zugriff auf jedes beliebige Element und muß die Elemente nicht wie
  114. bei Listen der Reihe nach durchgehen. Daraus resultiert ein
  115. Zeitvorteil, wenn man oft zwischen Teilen der Daten hin und her
  116. springen muß.
  117.  
  118.  
  119. Beschreibung der Prozeduren
  120. ­­­­­­­­­­­­­­­­­­­­­­­­­­­
  121. Es folgt eine Auflistung der auf den Typ "Row" möglichen Operationen:
  122. (genauere Informationen im Definitionsmodul)
  123.  
  124. * Dim()
  125.   erzeugt und initialisiert eine "Row" zur weiteren Benutzung.
  126.   Dim() muß vor irgend einer anderen Operation aufgerufen werden.
  127.  
  128. * Discard()
  129.   löscht eine Row mitsamt allen Elementen und gibt den verwendeten
  130.   Speicher frei.
  131.  
  132. * Write()
  133.   kopiert Daten von einer Variable (oder Konstante) in eine Row
  134.   an der indizierten Stelle.
  135.  
  136. * Read()
  137.   kopiert Daten aus einer indizierten Stelle einer Row in eine
  138.   Variable.
  139.  
  140. * High() und CompSize()
  141.   Diese Funktionen sind nützlich, wenn Rows als eine Art offene
  142.   Feldparameter in Prozeduren verwendet werden, und Länge und
  143.   Komponentengröße vorher nicht bekannt sind. Ähnlich wie HIGH()
  144.   für ARRAYs gibt High() den maximalen Index einer Row und
  145.   CompSize() die Länge deren Komponenten zurück.
  146.  
  147. * Import() und Export()
  148.   Diese Prozeduren können dazu benutzt werden, Rows auf (Disketten-)
  149.   Files zu schreiben oder von solchen zu lesen. Sie stellen eine
  150.   Schnittstelle zum Datenpuffer der Rows im Speicher zur Verfügung.
  151.   Es ist jedoch äußerste Vorsicht geboten! Die Verantwortung für die
  152.   Längen- und Typenkompatiblität liegt beim Anwender von Import()
  153.   und Export()!
  154.  
  155. Über die Parameter der Prozeduren und deren Bedeutung gibt das
  156. Definitionsmodul Auskunft.
  157.  
  158.  
  159. TestModul
  160. ­­­­­­­­­
  161. Das Modul "RowDemo" testet und demonstriert Rows und ihre Benutzung.
  162. Es Dim()ensioniert eine Row mit zufälliger Elementzahl, füllt sie
  163. mit Zufallszahlen und sortiert diese dann.
  164. Als Sortieralgorithmus wurde "Heapsort" gewählt, in dem nur die
  165. ":="-Zuweisungen durch Read()/Write() Befehle ersetzt wurden.
  166. Wenn Sie die Speicheranzeige der Workbench betrachten, während
  167. RowDemo läuft, sehen Sie, daß die Rows je nach ihrer Länge mehr
  168. oder weniger Speicher verbrauchen.
  169. (Für die Zyklenknauserer: Ja, ich weiß selbst, daß man den Heapsort
  170. noch opimieren könnte. Aber dies soll schließlich keine Geschwindig-
  171. keitsdemo sein.)
  172.  
  173.